package com.D5Power.basic
{
	import com.D5Power.loader.MutiLoader;
	import com.D5Power.utils.AvatarData;
	import com.D5Power.utils.AvatarData_RO;
	
	import flash.display.Bitmap;
	import flash.display.BitmapData;
	import flash.display.DisplayObject;
	import flash.display.IBitmapDrawable;
	import flash.events.Event;
	import flash.events.TimerEvent;
	import flash.geom.Matrix;
	import flash.geom.Rectangle;
	import flash.utils.Timer;
	import flash.utils.getQualifiedClassName;

	
	public class GraphicsResource
	{
		
		public static const MIRROR:String = '_mirror';
		
		/**
		 * 位图
		 */ 
		public var bitmap:BitmapData;

		/**
		 * 镜像位图
		 */
		public var mirrorBitmapData:BitmapData;

		/**
		 * 帧 数 动画的宽
		 */ 
		public var framesTotal:int = 1;
		
		/**
		 * 动画的层(高)数，对于角色就是方向
		 */ 
		public var framesLayer:int=1;
		
		/**
		 * 速度
		 */ 
		public var fps:Number = 0;
		
		/**
		 * 距形
		 */ 
		private var drawRect2:Rectangle;
		
		/**
		 * 实际现实的单元宽度
		 */ 
		public var frameWidth:Number=0;
		
		/**
		 * 实际现实的单元高度
		 */ 
		public var frameHeight:Number=0;
		
		/**
		 * 资源名
		 */ 
		private var _resName:String='';
		
		/**
		 * 
		 */ 
		private var _lineFrame:Array;
		
		/**
		 * 加载资源列表
		 */ 
		private var _loadResource:Array;
		
		/**
		 * 是否需要镜像
		 */ 
		private var _needMirror:Boolean;
		
		/**
		 * 本资源是否资源库的引用根源
		 */ 
		private var _isMaster:Boolean=false;
		
		/**
		 * 创建图形资源
		 * @param	data	可为bitmap也可以为AvatarData
		 * @param	resname	资源名，用来在资源池中寻找对象
		 */ 
		public function GraphicsResource(data:*,resname:String='', _framesTotal:int = 1,_framesLayer:int=1,
			 _fps:Number = 0, mirror:Boolean=false,
			 frameWidth:Number=0,frameHeight:Number=0)
		{
			
			_resName = resname;
			_needMirror = mirror;
			
			framesTotal = _framesTotal;
			framesLayer = _framesLayer;
			
			fps = _fps;
			
			
			if(data==null && _resName=='') return; // 若data为NULL，则是后期加载，如果此时resname也为空，则不需要进行缓存
			
			// 需要缓存，检查是否缓存根源
			if(data==null && _resName!='')
			{
				if(Global.resPool.getResource(_resName)==null)
				{
					_isMaster=Global.LOADWAIT.indexOf(_resName)==-1; // 当为-1说明加载列表中不存在，即为第一次加载,属于根资源
					Global.LOADWAIT.push(_resName);
					//trace("New Resource "+_resName+(_isMaster ? ' is Master' : ' not Master'));
					if(!_isMaster)
					{
						// 等待根资源加载完成
						var timer:Timer = new Timer(500);
						timer.addEventListener(TimerEvent.TIMER,rootComplate);
						timer.start();
					}
					return;
				}
			}
			
			var image:DisplayObject;
			
			// 如果存在资源名，检查资源池是否有匹配的资源
			if(_resName!='')
			{
				bitmap = Global.resPool.getResource(_resName);
				if(bitmap==null)
				{
					initBitmap(data);
					
					Global.resPool.addResource(_resName,bitmap);
					_isMaster = true;
					
					Global.resourceCount++;
					//trace('New Resource,'+_resName);
				}else{
					Global.resourcePoolCount++;
					//trace('Get Resource,'+_resName);
				}
				
				if(_needMirror)
				{
					mirrorBitmapData=Global.resPool.getResource(_resName+MIRROR);
					
					if(mirrorBitmapData==null)
					{
						mirrorBitmapData = createMirror(bitmap,bitmap.width,bitmap.height);
						Global.resPool.addResource(_resName+MIRROR,mirrorBitmapData);
					}
				}
			}else{
				initBitmap(data);
				mirrorBitmapData = createMirror(bitmap,bitmap.width,bitmap.height);
			}
			
			
			if(frameWidth==0 && frameHeight==0)
			{
				this.frameWidth=bitmap.width/framesTotal;
				this.frameHeight=bitmap.height/framesLayer;				
			}
			else
			{
				this.frameWidth=frameWidth;
				this.frameHeight=frameHeight;
				this.framesTotal=Math.ceil(bitmap.width/this.frameWidth);
				this.framesLayer=Math.ceil(bitmap.height/this.frameHeight);
			}

			image = null; // 断开引用
			data = null;
		}
		
		private function initBitmap(data:*):void
		{
			// 无匹配资源，开始构建
			if(data is AvatarData)
			{
				var image:DisplayObject = data.data;
				
				bitmap = createBitmapData(image,image.width,image.height);
			}else if(data is IBitmapDrawable){
				bitmap = createBitmapData(data,data.width,data.height);
			}
		}
		
		public function get resName():String
		{
			return _resName;
		}
		
		/**
		 * 直接通过URL地址数组来增加图形资源
		 * @param	list	包含URL地址的资源数组
		 */ 
		public function addLoadResource(list:Array):void
		{
			//trace("Resource "+_resName+' is '+_isMaster);
			if(!_isMaster) return;
			_loadResource=[];
			var mloader:MutiLoader = new MutiLoader(_loadResource);
			mloader.addEventListener(Event.COMPLETE,onResourceLoaded);
			mloader.loadDoc(list);
		}
		
		public function clear():void
		{
//			if(bitmap!=null)bitmap.dispose();
//			if(mirrorBitmapDataAlpha!=null)bitmapAlpha.dispose();
//			if(mirrorBitmapData!=null) mirrorBitmapData.dispose();
//			if(mirrorBitmapDataAlpha!=null) mirrorBitmapDataAlpha.dispose();
			
			bitmap = null;
			mirrorBitmapData=null;

		}
		
		public function getFrameTotal(line:uint):uint
		{
			if(_lineFrame==null || _lineFrame[line]==null)
				return framesTotal;
			else
				return _lineFrame[line];
		}
		
		/**
		 * 获取开始帧数，专门用于镜像计算
		 */ 
		public function getStartFrame(line:uint):uint
		{
			if(_lineFrame==null || _lineFrame[line]==null)
				return 0;		
			else
				return framesTotal-_lineFrame[line];
		}
		
		/**
		 * 设置各行最大帧数
		 */ 
		public function set lineFrame(arr:Array):void
		{
			_lineFrame = new Array();
			// 将数据复制过来
			for(var i:uint = 0;i<arr.length;i++)
			{
				_lineFrame.push(arr[i]);
			}
		}
		/**
		 * 创建位图
		 */ 
		protected function createBitmapData(image:IBitmapDrawable,w:uint,h:uint):BitmapData
		{
			var bitmap2:BitmapData = new BitmapData(w, h,true,0x00000000);
			bitmap2.draw(image);
			return bitmap2;
		}
		
		/**
		 * 从显示对象创建镜像
		 */ 
		protected function createMirror(image:IBitmapDrawable,w:uint,h:uint):BitmapData
		{
			var matrix:Matrix=new Matrix(-1,0,0,1,w);
			
			var bitmap2:BitmapData = new BitmapData(w, h,true,0x00000000);
			bitmap2.draw(image,matrix, null);
			return bitmap2;
		}
		
		private function updateFrameConfig():void
		{
			frameWidth = int(bitmap.width/framesTotal);
			frameHeight = int(bitmap.height/framesLayer);
		}
		
		private function rootComplate(e:TimerEvent):void
		{
			
			bitmap = Global.resPool.getResource(_resName);
			if(bitmap!=null)
			{
				var timer:Timer = e.target as Timer;
				timer.stop();
				timer.removeEventListener(TimerEvent.TIMER,rootComplate);
				
				if(_needMirror) mirrorBitmapData = Global.resPool.getResource(_resName+MIRROR);

				//trace('Get Load Resource,'+_resName);
				Global.resourcePoolCount++;
				updateFrameConfig();
			}
			
			//trace("Run roomComplate");
		}

		
		private function onResourceLoaded(e:Event):void
		{
			var breakZero:Boolean=false;
			if(bitmap==null)
			{
				bitmap = new BitmapData(_loadResource[0].width,_loadResource[0].height,true,0x00000000);
				bitmap.draw(_loadResource[0]);
				breakZero=true;
				
				updateFrameConfig();
			}
			
			// 由于资源库中使用的是对第一对象
			
			var i:uint=0;
			for each(var d:DisplayObject in _loadResource)
			{
				if(breakZero && i==0) continue;
				bitmap.draw(d);	
				i++;
			}
			
			
			
			_loadResource.splice(0,_loadResource.length);
			_loadResource = null;
			
			var target:MutiLoader = e.target as MutiLoader;
			target.removeEventListener(Event.COMPLETE,onResourceLoaded);
			target.clear();
			
			if(_needMirror)
			{
				mirrorBitmapData = createMirror(bitmap,bitmap.width,bitmap.height);
				if(_resName!='') Global.resPool.updateResource(_resName+MIRROR,mirrorBitmapData);
			}
			
			if(breakZero)
			{
				//trace('New Load Resource,'+_resName);
				Global.resourceCount++;
				Global.resPool.addResource(_resName,bitmap);
			}
			
			
		}
	
	}
		
}